#pragma once

using namespace System::Collections::Generic;
using namespace System;

#include "ValueHelpers.h"

namespace Cephei
{
//z	[FactoryFor(Core::Generic::ICoCell<Double>::typeid)]
	[FactoryFor(Double::typeid)]
	[FactoryFor(Cephei::Core::IDouble_Factory::typeid)]
	public ref class CDouble_Factory : public IDouble_Factory 
	{
	public:
		virtual IVector<Double>^ CreateVector ()
		{
			return gcnew CoVector<Double> (gcnew CDoubleVector);
		}
		virtual IVector<Double>^ CreateVector (System::Collections::Generic::IEnumerable<Double>^ source)
		{
			return gcnew CoVector<Double> (source, gcnew CDoubleVector ());
		}

		virtual IMatrix<Double>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Double> (gcnew CDoubleMatrix);
		}
		virtual IMatrix<Double>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Double>^>^ source)
		{
			return gcnew CoMatrix<Double> (source, gcnew CDoubleMatrix ());
		}

		virtual ICube<Double>^ CreateCube ()
		{
			return gcnew CoCube<Double> (gcnew CDoubleCube);
		}
		virtual ICube<Double>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Double>^>^>^ source)
		{
			return gcnew CoCube<Double> (source, gcnew CDoubleCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Double>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellVector<Double> (gcnew CDoubleVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Double>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Double>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellVector<Double> (source, gcnew CDoubleVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Double>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellMatrix<Double> (gcnew CDoubleMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Double>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Double>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellMatrix<Double> (source, gcnew CDoubleMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Double>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellCube<Double> (gcnew CDoubleCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Double>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Double>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Double>^>^> (gcnew CoCellCube<Double> (source, gcnew CDoubleCube()));
		}
        virtual INativeVector<Double>^ CreateNativeVector ()
		{
			return gcnew CDoubleVector ();
		}
        virtual INativeMatrix<Double>^ CreateNativeMatrix ()
		{
			return gcnew CDoubleMatrix ();
		}
        virtual INativeCube<Double>^ CreateNativeCube ()
		{
			return gcnew CDoubleCube ();
		}
		virtual Core::Generic::ICoCell<double>^ Create ()
		{
			return CellFactory::Instance->Create<double> ();
		}
		virtual Core::Generic::ICoCell<double>^ Create (double d)
		{
			return CellFactory::Instance->Create<double> (d);
		}
	};


//z	[FactoryFor(Core::Generic::ICoCell<Int32>::typeid)]
	[FactoryFor(Int32::typeid)]
	[FactoryFor(Cephei::Core::IInt_Factory::typeid)]
	public ref class CInt_Factory : public IInt_Factory 
	{
	public:
		virtual IVector<Int32>^ CreateVector ()
		{
			return gcnew CoVector<Int32> (gcnew CInt32Vector);
		}
		virtual IVector<Int32>^ CreateVector (System::Collections::Generic::IEnumerable<Int32>^ source)
		{
			return gcnew CoVector<Int32> (source, gcnew CInt32Vector ());
		}

		virtual IMatrix<Int32>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Int32> (gcnew CInt32Matrix);
		}
		virtual IMatrix<Int32>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Int32>^>^ source)
		{
			return gcnew CoMatrix<Int32> (source, gcnew CInt32Matrix ());
		}

		virtual ICube<Int32>^ CreateCube ()
		{
			return gcnew CoCube<Int32> (gcnew CInt32Cube);
		}
		virtual ICube<Int32>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Int32>^>^>^ source)
		{
			return gcnew CoCube<Int32> (source, gcnew CInt32Cube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Int32>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellVector<Int32> (gcnew CInt32Vector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Int32>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int32>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellVector<Int32> (source, gcnew CInt32Vector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Int32>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellMatrix<Int32> (gcnew CInt32Matrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Int32>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int32>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellMatrix<Int32> (source, gcnew CInt32Matrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Int32>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellCube<Int32> (gcnew CInt32Cube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Int32>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int32>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Int32>^>^> (gcnew CoCellCube<Int32> (source, gcnew CInt32Cube()));
		}
        virtual INativeVector<Int32>^ CreateNativeVector ()
		{
			return gcnew CIntVector ();
		}
        virtual INativeMatrix<Int32>^ CreateNativeMatrix ()
		{
			return gcnew CIntMatrix ();
		}
        virtual INativeCube<Int32>^ CreateNativeCube ()
        {
			return gcnew CIntCube ();
		}
		virtual Core::Generic::ICoCell<Int32>^ Create ()
		{
			return CellFactory::Instance->Create<Int32> ();
		}
		virtual Core::Generic::ICoCell<Int32>^ Create (Int32 d)
		{
			return CellFactory::Instance->Create<Int32> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<UInt32>::typeid)]
	[FactoryFor(UInt32::typeid)]
	[FactoryFor(Cephei::Core::IUInt_Factory::typeid)]
	public ref class CUInt_Factory : public IUInt_Factory 
	{
	public:
		virtual IVector<UInt32>^ CreateVector ()
		{
			return gcnew CoVector<UInt32> (gcnew CUInt32Vector);
		}
		virtual IVector<UInt32>^ CreateVector (System::Collections::Generic::IEnumerable<UInt32>^ source)
		{
			return gcnew CoVector<UInt32> (source, gcnew CUInt32Vector ());
		}

		virtual IMatrix<UInt32>^ CreateMatrix ()
		{
			return gcnew CoMatrix<UInt32> (gcnew CUInt32Matrix);
		}
		virtual IMatrix<UInt32>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<UInt32>^>^ source)
		{
			return gcnew CoMatrix<UInt32> (source, gcnew CUInt32Matrix ());
		}

		virtual ICube<UInt32>^ CreateCube ()
		{
			return gcnew CoCube<UInt32> (gcnew CUInt32Cube);
		}
		virtual ICube<UInt32>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<UInt32>^>^>^ source)
		{
			return gcnew CoCube<UInt32> (source, gcnew CUInt32Cube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellVector<UInt32> (gcnew CUInt32Vector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt32>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellVector<UInt32> (source, gcnew CUInt32Vector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellMatrix<UInt32> (gcnew CUInt32Matrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt32>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellMatrix<UInt32> (source, gcnew CUInt32Matrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellCube<UInt32> (gcnew CUInt32Cube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<UInt32>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt32>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<UInt32>^>^> (gcnew CoCellCube<UInt32> (source, gcnew CUInt32Cube()));
		}
        virtual INativeVector<UInt32>^ CreateNativeVector ()
		{
			return gcnew CUIntVector ();
		}
        virtual INativeMatrix<UInt32>^ CreateNativeMatrix ()
		{
			return gcnew CUIntMatrix ();
		}
        virtual INativeCube<UInt32>^ CreateNativeCube ()
        {
			return gcnew CUIntCube ();
		}
		virtual Core::Generic::ICoCell<UInt32>^ Create ()
		{
			return CellFactory::Instance->Create<UInt32> ();
		}
		virtual Core::Generic::ICoCell<UInt32>^ Create (UInt32 d)
		{
			return CellFactory::Instance->Create<UInt32> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<Int64>::typeid)]
	[FactoryFor(Int64::typeid)]
	[FactoryFor(Cephei::Core::ILong_Factory::typeid)]
	public ref class CLong_Factory : public ILong_Factory 
	{
	public:
		virtual IVector<Int64>^ CreateVector ()
		{
			return gcnew CoVector<Int64> (gcnew CLongVector);
		}
		virtual IVector<Int64>^ CreateVector (System::Collections::Generic::IEnumerable<Int64>^ source)
		{
			return gcnew CoVector<Int64> (source, gcnew CLongVector ());
		}

		virtual IMatrix<Int64>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Int64> (gcnew CLongMatrix);
		}
		virtual IMatrix<Int64>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Int64>^>^ source)
		{
			return gcnew CoMatrix<Int64> (source, gcnew CLongMatrix ());
		}

		virtual ICube<Int64>^ CreateCube ()
		{
			return gcnew CoCube<Int64> (gcnew CLongCube);
		}
		virtual ICube<Int64>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Int64>^>^>^ source)
		{
			return gcnew CoCube<Int64> (source, gcnew CLongCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Int64>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellVector<Int64> (gcnew CLongVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Int64>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int64>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellVector<Int64> (source, gcnew CLongVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Int64>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellMatrix<Int64> (gcnew CLongMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Int64>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int64>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellMatrix<Int64> (source, gcnew CLongMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Int64>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellCube<Int64> (gcnew CLongCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Int64>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Int64>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Int64>^>^> (gcnew CoCellCube<Int64> (source, gcnew CLongCube()));
		}
        virtual INativeVector<Int64>^ CreateNativeVector ()
		{
			return gcnew CLongVector ();
		}
        virtual INativeMatrix<Int64>^ CreateNativeMatrix ()
		{
			return gcnew CLongMatrix ();
		}
        virtual INativeCube<Int64>^ CreateNativeCube ()
        {
			return gcnew CLongCube ();
		}
		virtual Core::Generic::ICoCell<Int64>^ Create ()
		{
			return CellFactory::Instance->Create<Int64> ();
		}
		virtual Core::Generic::ICoCell<Int64>^ Create (Int64 d)
		{
			return CellFactory::Instance->Create<Int64> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<UInt64>::typeid)]
	[FactoryFor(UInt64::typeid)]
	[FactoryFor(Cephei::Core::IULong_Factory::typeid)]
	public ref class CULong_Factory : public IULong_Factory 
	{
	public:
		virtual IVector<UInt64>^ CreateVector ()
		{
			return gcnew CoVector<UInt64> (gcnew CULongVector);
		}
		virtual IVector<UInt64>^ CreateVector (System::Collections::Generic::IEnumerable<UInt64>^ source)
		{
			return gcnew CoVector<UInt64> (source, gcnew CULongVector ());
		}

		virtual IMatrix<UInt64>^ CreateMatrix ()
		{
			return gcnew CoMatrix<UInt64> (gcnew CULongMatrix);
		}
		virtual IMatrix<UInt64>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<UInt64>^>^ source)
		{
			return gcnew CoMatrix<UInt64> (source, gcnew CULongMatrix ());
		}

		virtual ICube<UInt64>^ CreateCube ()
		{
			return gcnew CoCube<UInt64> (gcnew CULongCube);
		}
		virtual ICube<UInt64>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<UInt64>^>^>^ source)
		{
			return gcnew CoCube<UInt64> (source, gcnew CULongCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellVector<UInt64> (gcnew CULongVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt64>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellVector<UInt64> (source, gcnew CULongVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellMatrix<UInt64> (gcnew CULongMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt64>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellMatrix<UInt64> (source, gcnew CULongMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellCube<UInt64> (gcnew CULongCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<UInt64>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<UInt64>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<UInt64>^>^> (gcnew CoCellCube<UInt64> (source, gcnew CULongCube()));
		}
        virtual INativeVector<UInt64>^ CreateNativeVector ()
		{
			return gcnew CULongVector ();
		}
        virtual INativeMatrix<UInt64>^ CreateNativeMatrix ()
		{
			return gcnew CULongMatrix ();
		}
        virtual INativeCube<UInt64>^ CreateNativeCube ()
        {
			return gcnew CULongCube ();
		}
		virtual Core::Generic::ICoCell<UInt64>^ Create ()
		{
			return CellFactory::Instance->Create<UInt64> ();
		}
		virtual Core::Generic::ICoCell<UInt64>^ Create (UInt64 d)
		{
			return CellFactory::Instance->Create<UInt64> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<DateTime>::typeid)]
	[FactoryFor(DateTime::typeid)]
	[FactoryFor(Cephei::Core::IDateTime_Factory::typeid)]
	public ref class CDateTime_Factory : public IDateTime_Factory 
	{
	public:
		virtual IVector<DateTime>^ CreateVector ()
		{
			return gcnew CoVector<DateTime> (gcnew CDateTimeVector);
		}
		virtual IVector<DateTime>^ CreateVector (System::Collections::Generic::IEnumerable<DateTime>^ source)
		{
			return gcnew CoVector<DateTime> (source, gcnew CDateTimeVector ());
		}

		virtual IMatrix<DateTime>^ CreateMatrix ()
		{
			return gcnew CoMatrix<DateTime> (gcnew CDateTimeMatrix);
		}
		virtual IMatrix<DateTime>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<DateTime>^>^ source)
		{
			return gcnew CoMatrix<DateTime> (source, gcnew CDateTimeMatrix ());
		}

		virtual ICube<DateTime>^ CreateCube ()
		{
			return gcnew CoCube<DateTime> (gcnew CDateTimeCube);
		}
		virtual ICube<DateTime>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<DateTime>^>^>^ source)
		{
			return gcnew CoCube<DateTime> (source, gcnew CDateTimeCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellVector<DateTime> (gcnew CDateTimeVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<DateTime>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellVector<DateTime> (source, gcnew CDateTimeVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellMatrix<DateTime> (gcnew CDateTimeMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<DateTime>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellMatrix<DateTime> (source, gcnew CDateTimeMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellCube<DateTime> (gcnew CDateTimeCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<DateTime>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<DateTime>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<DateTime>^>^> (gcnew CoCellCube<DateTime> (source, gcnew CDateTimeCube()));
		}
        virtual INativeVector<DateTime>^ CreateNativeVector ()
		{
			return gcnew CDateTimeVector ();
		}
        virtual INativeMatrix<DateTime>^ CreateNativeMatrix ()
		{
			return gcnew CDateTimeMatrix ();
		}
        virtual INativeCube<DateTime>^ CreateNativeCube ()
        {
			return gcnew CDateTimeCube ();
		}
		virtual Core::Generic::ICoCell<DateTime>^ Create ()
		{
			return CellFactory::Instance->Create<DateTime> ();
		}
		virtual Core::Generic::ICoCell<DateTime>^ Create (DateTime d)
		{
			return CellFactory::Instance->Create<DateTime> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<String^>::typeid)]
	[FactoryFor(String::typeid)]
	[FactoryFor(Cephei::Core::IString_Factory::typeid)]
	public ref class CString_Factory : public IString_Factory 
	{
	public:
		virtual IVector<String^>^ CreateVector ()
		{
			return gcnew CoVector<String^> (gcnew CStringVector);
		}
		virtual IVector<String^>^ CreateVector (System::Collections::Generic::IEnumerable<String^>^ source)
		{
			return gcnew CoVector<String^> (source, gcnew CStringVector ());
		}

		virtual IMatrix<String^>^ CreateMatrix ()
		{
			return gcnew CoMatrix<String^> (gcnew CStringMatrix);
		}
		virtual IMatrix<String^>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<String^>^>^ source)
		{
			return gcnew CoMatrix<String^> (source, gcnew CStringMatrix ());
		}

		virtual ICube<String^>^ CreateCube ()
		{
			return gcnew CoCube<String^> (gcnew CStringCube);
		}
		virtual ICube<String^>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<String^>^>^>^ source)
		{
			return gcnew CoCube<String^> (source, gcnew CStringCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<String^>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellVector<String^> (gcnew CStringVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<String^>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<String^>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellVector<String^> (source, gcnew CStringVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<String^>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellMatrix<String^> (gcnew CStringMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<String^>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<String^>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellMatrix<String^> (source, gcnew CStringMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<String^>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellCube<String^> (gcnew CStringCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<String^>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<String^>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<String^>^>^> (gcnew CoCellCube<String^> (source, gcnew CStringCube()));
		}
        virtual INativeVector<String^>^ CreateNativeVector ()
		{
			return gcnew CStringVector ();
		}
        virtual INativeMatrix<String^>^ CreateNativeMatrix ()
		{
			return gcnew CStringMatrix ();
		}
        virtual INativeCube<String^>^ CreateNativeCube ()
        {
			return gcnew CStringCube ();
		}
		virtual Core::Generic::ICoCell<String^>^ Create ()
		{
			return CellFactory::Instance->Create<String^> ();
		}
		virtual Core::Generic::ICoCell<String^>^ Create (String^ d)
		{
			return CellFactory::Instance->Create<String^> (d);
		}
	};

//z	[FactoryFor(Core::Generic::ICoCell<Boolean>::typeid)]
	[FactoryFor(Boolean::typeid)]
	[FactoryFor(Cephei::Core::IBool_Factory::typeid)]
	public ref class CBool_Factory : public IBool_Factory 
	{
	public:
		virtual IVector<Boolean>^ CreateVector ()
		{
			return gcnew CoVector<Boolean> (gcnew CBooleanVector);
		}
		virtual IVector<Boolean>^ CreateVector (System::Collections::Generic::IEnumerable<Boolean>^ source)
		{
			return gcnew CoVector<Boolean> (source, gcnew CBooleanVector ());
		}

		virtual IMatrix<Boolean>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Boolean> (gcnew CBooleanMatrix);
		}
		virtual IMatrix<Boolean>^ CreateMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Boolean>^>^ source)
		{
			return gcnew CoMatrix<Boolean> (source, gcnew CBooleanMatrix ());
		}

		virtual ICube<Boolean>^ CreateCube ()
		{
			return gcnew CoCube<Boolean> (gcnew CBooleanCube);
		}
		virtual ICube<Boolean>^ CreateCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Boolean>^>^>^ source)
		{
			return gcnew CoCube<Boolean> (source, gcnew CBooleanCube());
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellVector ()
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellVector<Boolean> (gcnew CBooleanVector()));
		}

		virtual Core::Generic::ICoCell<IVector<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Boolean>^>^ source)
		{
			return CellFactory::Instance->Create<IVector<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellVector<Boolean> (source, gcnew CBooleanVector()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellMatrix ()
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellMatrix<Boolean> (gcnew CBooleanMatrix()));
		}

		virtual Core::Generic::ICoCell<IMatrix<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Boolean>^>^>^ source)
		{
			return CellFactory::Instance->Create<IMatrix<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellMatrix<Boolean> (source, gcnew CBooleanMatrix()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellCube ()
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellCube<Boolean> (gcnew CBooleanCube()));
		}

		virtual Core::Generic::ICoCell<ICube<Core::Generic::ICoCell<Boolean>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<System::Collections::Generic::IEnumerable<Core::Generic::ICoCell<Boolean>^>^>^>^ source)
		{
			return CellFactory::Instance->Create<ICube<Core::Generic::ICoCell<Boolean>^>^> (gcnew CoCellCube<Boolean> (source, gcnew CBooleanCube()));
		}
        virtual INativeVector<Boolean>^ CreateNativeVector ()
		{
			return gcnew CBooleanVector ();
		}
        virtual INativeMatrix<Boolean>^ CreateNativeMatrix ()
		{
			return gcnew CBooleanMatrix ();
		}
        virtual INativeCube<Boolean>^ CreateNativeCube ()
        {
			return gcnew CBooleanCube ();
		}
		virtual Core::Generic::ICoCell<Boolean>^ Create ()
		{
			return CellFactory::Instance->Create<Boolean> ();
		}
		virtual Core::Generic::ICoCell<Boolean>^ Create (Boolean d)
		{
			return CellFactory::Instance->Create<Boolean> (d);
		}
	};
}
